home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / markupbase.pyo (.txt) < prev    next >
Python Compiled Bytecode  |  2008-10-13  |  9KB  |  391 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. import re
  5. _declname_match = re.compile('[a-zA-Z][-_.a-zA-Z0-9]*\\s*').match
  6. _declstringlit_match = re.compile('(\\\'[^\\\']*\\\'|"[^"]*")\\s*').match
  7. _commentclose = re.compile('--\\s*>')
  8. _markedsectionclose = re.compile(']\\s*]\\s*>')
  9. _msmarkedsectionclose = re.compile(']\\s*>')
  10. del re
  11.  
  12. class ParserBase:
  13.     
  14.     def __init__(self):
  15.         if self.__class__ is ParserBase:
  16.             raise RuntimeError('markupbase.ParserBase must be subclassed')
  17.         
  18.  
  19.     
  20.     def error(self, message):
  21.         raise NotImplementedError('subclasses of ParserBase must override error()')
  22.  
  23.     
  24.     def reset(self):
  25.         self.lineno = 1
  26.         self.offset = 0
  27.  
  28.     
  29.     def getpos(self):
  30.         return (self.lineno, self.offset)
  31.  
  32.     
  33.     def updatepos(self, i, j):
  34.         if i >= j:
  35.             return j
  36.         
  37.         rawdata = self.rawdata
  38.         nlines = rawdata.count('\n', i, j)
  39.         if nlines:
  40.             self.lineno = self.lineno + nlines
  41.             pos = rawdata.rindex('\n', i, j)
  42.             self.offset = j - pos + 1
  43.         else:
  44.             self.offset = self.offset + j - i
  45.         return j
  46.  
  47.     _decl_otherchars = ''
  48.     
  49.     def parse_declaration(self, i):
  50.         rawdata = self.rawdata
  51.         j = i + 2
  52.         if rawdata[j:j + 1] == '>':
  53.             return j + 1
  54.         
  55.         if rawdata[j:j + 1] in ('-', ''):
  56.             return -1
  57.         
  58.         n = len(rawdata)
  59.         if rawdata[j:j + 2] == '--':
  60.             return self.parse_comment(i)
  61.         elif rawdata[j] == '[':
  62.             return self.parse_marked_section(i)
  63.         else:
  64.             (decltype, j) = self._scan_name(j, i)
  65.         if j < 0:
  66.             return j
  67.         
  68.         if decltype == 'doctype':
  69.             self._decl_otherchars = ''
  70.         
  71.         while j < n:
  72.             c = rawdata[j]
  73.             if c == '>':
  74.                 data = rawdata[i + 2:j]
  75.                 if decltype == 'doctype':
  76.                     self.handle_decl(data)
  77.                 else:
  78.                     self.unknown_decl(data)
  79.                 return j + 1
  80.             
  81.             if c in '"\'':
  82.                 m = _declstringlit_match(rawdata, j)
  83.                 if not m:
  84.                     return -1
  85.                 
  86.                 j = m.end()
  87.             elif c in 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ':
  88.                 (name, j) = self._scan_name(j, i)
  89.             elif c in self._decl_otherchars:
  90.                 j = j + 1
  91.             elif c == '[':
  92.                 if decltype == 'doctype':
  93.                     j = self._parse_doctype_subset(j + 1, i)
  94.                 elif decltype in ('attlist', 'linktype', 'link', 'element'):
  95.                     self.error("unsupported '[' char in %s declaration" % decltype)
  96.                 else:
  97.                     self.error("unexpected '[' char in declaration")
  98.             else:
  99.                 self.error('unexpected %r char in declaration' % rawdata[j])
  100.             if j < 0:
  101.                 return j
  102.                 continue
  103.         return -1
  104.  
  105.     
  106.     def parse_marked_section(self, i, report = 1):
  107.         rawdata = self.rawdata
  108.         (sectName, j) = self._scan_name(i + 3, i)
  109.         if j < 0:
  110.             return j
  111.         
  112.         if sectName in ('temp', 'cdata', 'ignore', 'include', 'rcdata'):
  113.             match = _markedsectionclose.search(rawdata, i + 3)
  114.         elif sectName in ('if', 'else', 'endif'):
  115.             match = _msmarkedsectionclose.search(rawdata, i + 3)
  116.         else:
  117.             self.error('unknown status keyword %r in marked section' % rawdata[i + 3:j])
  118.         if not match:
  119.             return -1
  120.         
  121.         if report:
  122.             j = match.start(0)
  123.             self.unknown_decl(rawdata[i + 3:j])
  124.         
  125.         return match.end(0)
  126.  
  127.     
  128.     def parse_comment(self, i, report = 1):
  129.         rawdata = self.rawdata
  130.         if rawdata[i:i + 4] != '<!--':
  131.             self.error('unexpected call to parse_comment()')
  132.         
  133.         match = _commentclose.search(rawdata, i + 4)
  134.         if not match:
  135.             return -1
  136.         
  137.         if report:
  138.             j = match.start(0)
  139.             self.handle_comment(rawdata[i + 4:j])
  140.         
  141.         return match.end(0)
  142.  
  143.     
  144.     def _parse_doctype_subset(self, i, declstartpos):
  145.         rawdata = self.rawdata
  146.         n = len(rawdata)
  147.         j = i
  148.         while j < n:
  149.             c = rawdata[j]
  150.             if c == '<':
  151.                 s = rawdata[j:j + 2]
  152.                 if s == '<':
  153.                     return -1
  154.                 
  155.                 if s != '<!':
  156.                     self.updatepos(declstartpos, j + 1)
  157.                     self.error('unexpected char in internal subset (in %r)' % s)
  158.                 
  159.                 if j + 2 == n:
  160.                     return -1
  161.                 
  162.                 if j + 4 > n:
  163.                     return -1
  164.                 
  165.                 if rawdata[j:j + 4] == '<!--':
  166.                     j = self.parse_comment(j, report = 0)
  167.                     if j < 0:
  168.                         return j
  169.                         continue
  170.                     continue
  171.                 
  172.                 (name, j) = self._scan_name(j + 2, declstartpos)
  173.                 if j == -1:
  174.                     return -1
  175.                 
  176.                 if name not in ('attlist', 'element', 'entity', 'notation'):
  177.                     self.updatepos(declstartpos, j + 2)
  178.                     self.error('unknown declaration %r in internal subset' % name)
  179.                 
  180.                 meth = getattr(self, '_parse_doctype_' + name)
  181.                 j = meth(j, declstartpos)
  182.                 if j < 0:
  183.                     return j
  184.                 
  185.             j < 0
  186.             if c == '%':
  187.                 if j + 1 == n:
  188.                     return -1
  189.                 
  190.                 (s, j) = self._scan_name(j + 1, declstartpos)
  191.                 if j < 0:
  192.                     return j
  193.                 
  194.                 if rawdata[j] == ';':
  195.                     j = j + 1
  196.                 
  197.             rawdata[j] == ';'
  198.             if c == ']':
  199.                 j = j + 1
  200.                 while j < n and rawdata[j].isspace():
  201.                     j = j + 1
  202.                 if j < n:
  203.                     if rawdata[j] == '>':
  204.                         return j
  205.                     
  206.                     self.updatepos(declstartpos, j)
  207.                     self.error('unexpected char after internal subset')
  208.                 else:
  209.                     return -1
  210.             j < n
  211.             if c.isspace():
  212.                 j = j + 1
  213.                 continue
  214.             self.updatepos(declstartpos, j)
  215.             self.error('unexpected char %r in internal subset' % c)
  216.         return -1
  217.  
  218.     
  219.     def _parse_doctype_element(self, i, declstartpos):
  220.         (name, j) = self._scan_name(i, declstartpos)
  221.         if j == -1:
  222.             return -1
  223.         
  224.         rawdata = self.rawdata
  225.         if '>' in rawdata[j:]:
  226.             return rawdata.find('>', j) + 1
  227.         
  228.         return -1
  229.  
  230.     
  231.     def _parse_doctype_attlist(self, i, declstartpos):
  232.         rawdata = self.rawdata
  233.         (name, j) = self._scan_name(i, declstartpos)
  234.         c = rawdata[j:j + 1]
  235.         if c == '':
  236.             return -1
  237.         
  238.         if c == '>':
  239.             return j + 1
  240.         
  241.         while None:
  242.             (name, j) = self._scan_name(j, declstartpos)
  243.             if j < 0:
  244.                 return j
  245.             
  246.             c = rawdata[j:j + 1]
  247.             if c == '':
  248.                 return -1
  249.             
  250.             if c == '(':
  251.                 if ')' in rawdata[j:]:
  252.                     j = rawdata.find(')', j) + 1
  253.                 else:
  254.                     return -1
  255.                 while rawdata[j:j + 1].isspace():
  256.                     j = j + 1
  257.                 if not rawdata[j:]:
  258.                     return -1
  259.                 
  260.             else:
  261.                 (name, j) = self._scan_name(j, declstartpos)
  262.             c = rawdata[j:j + 1]
  263.             if not c:
  264.                 return -1
  265.             
  266.             if c in '\'"':
  267.                 m = _declstringlit_match(rawdata, j)
  268.                 if m:
  269.                     j = m.end()
  270.                 else:
  271.                     return -1
  272.                 c = rawdata[j:j + 1]
  273.                 if not c:
  274.                     return -1
  275.                 
  276.             
  277.             if c == '#':
  278.                 if rawdata[j:] == '#':
  279.                     return -1
  280.                 
  281.                 (name, j) = self._scan_name(j + 1, declstartpos)
  282.                 if j < 0:
  283.                     return j
  284.                 
  285.                 c = rawdata[j:j + 1]
  286.                 if not c:
  287.                     return -1
  288.                 
  289.             
  290.             if c == '>':
  291.                 return j + 1
  292.                 continue
  293.             continue
  294.             return None
  295.  
  296.     
  297.     def _parse_doctype_notation(self, i, declstartpos):
  298.         (name, j) = self._scan_name(i, declstartpos)
  299.         if j < 0:
  300.             return j
  301.         
  302.         rawdata = self.rawdata
  303.         while None:
  304.             c = rawdata[j:j + 1]
  305.             if not c:
  306.                 return -1
  307.             
  308.             if c == '>':
  309.                 return j + 1
  310.             
  311.             if c in '\'"':
  312.                 m = _declstringlit_match(rawdata, j)
  313.                 if not m:
  314.                     return -1
  315.                 
  316.                 j = m.end()
  317.                 continue
  318.             (name, j) = self._scan_name(j, declstartpos)
  319.             if j < 0:
  320.                 return j
  321.                 continue
  322.             continue
  323.             return None
  324.  
  325.     
  326.     def _parse_doctype_entity(self, i, declstartpos):
  327.         rawdata = self.rawdata
  328.         if rawdata[i:i + 1] == '%':
  329.             j = i + 1
  330.             while None:
  331.                 c = rawdata[j:j + 1]
  332.                 if not c:
  333.                     return -1
  334.                 
  335.                 if c.isspace():
  336.                     j = j + 1
  337.                     continue
  338.                 break
  339.                 continue
  340.         rawdata[i:i + 1] == '%'
  341.         j = i
  342.         (name, j) = self._scan_name(j, declstartpos)
  343.         if j < 0:
  344.             return j
  345.         
  346.         while None:
  347.             c = self.rawdata[j:j + 1]
  348.             if not c:
  349.                 return -1
  350.             
  351.             if c in '\'"':
  352.                 m = _declstringlit_match(rawdata, j)
  353.                 if m:
  354.                     j = m.end()
  355.                 else:
  356.                     return -1
  357.             if c == '>':
  358.                 return j + 1
  359.                 continue
  360.             (name, j) = self._scan_name(j, declstartpos)
  361.             if j < 0:
  362.                 return j
  363.                 continue
  364.             continue
  365.             return None
  366.  
  367.     
  368.     def _scan_name(self, i, declstartpos):
  369.         rawdata = self.rawdata
  370.         n = len(rawdata)
  371.         if i == n:
  372.             return (None, -1)
  373.         
  374.         m = _declname_match(rawdata, i)
  375.         if m:
  376.             s = m.group()
  377.             name = s.strip()
  378.             if i + len(s) == n:
  379.                 return (None, -1)
  380.             
  381.             return (name.lower(), m.end())
  382.         else:
  383.             self.updatepos(declstartpos, i)
  384.             self.error('expected name token at %r' % rawdata[declstartpos:declstartpos + 20])
  385.  
  386.     
  387.     def unknown_decl(self, data):
  388.         pass
  389.  
  390.  
  391.